services/workspace_listing.py (1)

93-100: 🚀 Performance & Scalability | 🔵 Trivial | 🏗️ Heavy lift

Keep project-cache hits from doing full orchestration work.

prepare_workspace_orchestration() resolves workspace context and display maps before get_cached_projects(), but cache hits only need the fingerprint. Consider splitting fingerprint preparation from full orchestration or making the context/display-map fields lazy so cached workspace listings return cheaply.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@services/workspace_listing.py` around lines 93 - 100, The issue is that
prepare_workspace_orchestration() performs expensive work resolving workspace
context and display maps before checking get_cached_projects() for a cache hit.
Restructure the logic to compute only the fingerprint first (before full
orchestration), check get_cached_projects() with that fingerprint, and only
invoke the complete prepare_workspace_orchestration() if the cache check misses,
avoiding unnecessary work when returning cached results.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

services/workspace_listing.py (1)

96-118: 🚀 Performance & Scalability | 🔵 Trivial

Duplicated fingerprint computation introduces a latent cache-key divergence risk.

The inline block (lines 100–108) recomputes global_storage_db_path, get_cli_chats_path, and fingerprint_workspace_storage identically to how prepare_workspace_orchestration does so internally (export_engine.py lines 129–135). On a cache miss this duplicates I/O, and more critically, the read key (fingerprint, line 109) and write key (orch.fingerprint, line 124) are produced by two separate copies of the same logic. They are byte-identical today, but if either site's conditional gating (e.g., os.path.isfile/os.path.isdir) or the rules argument ever change, cache reads and writes would key on different fingerprints, silently breaking the cache.

Consider threading the precomputed fingerprint into prepare_workspace_orchestration to maintain a single source of truth while preserving the cheap cache-hit short-circuit before the expensive ctx/display-map resolution.

♻️ Sketch: pass the computed fingerprint through

     orch = prepare_workspace_orchestration(
         workspace_path,
         rules,
         nocache=effective_nocache,
         workspace_entries=workspace_entries,
+        fingerprint=fingerprint if not effective_nocache else None,
     )

This requires adding a keyword-only fingerprint: dict[str, Any] | None = None parameter to prepare_workspace_orchestration that, when provided, is used instead of recomputing. That keeps a single fingerprint definition and removes the duplicate stat lookups on the cache-miss path.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@services/workspace_listing.py` around lines 96 - 118, The fingerprint
computation in the inline block (lines 100-108) duplicates the identical logic
that prepare_workspace_orchestration performs internally, creating a cache-key
divergence risk if either implementation changes. Add a keyword-only fingerprint
parameter to prepare_workspace_orchestration with a default value of None, then
modify the function to use the provided fingerprint when available instead of
recomputing it. In the calling code within workspace_listing.py, pass the
computed fingerprint value to prepare_workspace_orchestration to eliminate the
duplication while preserving the cache-hit short-circuit before expensive
orchestration operations.

services/export_engine.py (1)

386-392: 🩺 Stability & Availability | 🟠 Major | ⚡ Quick win

Guard session["meta"] shape before .get() calls.

At Lines 386-392, if meta is present but not a dict (or None), this raises AttributeError before the session-level read/parse guard, causing the whole export to fail on one bad session.

Suggested fix

-            meta = session.get("meta", {})
+            raw_meta = session.get("meta")
+            meta = raw_meta if isinstance(raw_meta, dict) else {}
             session_id = session["session_id"]
             created_raw = meta.get("createdAt")
             created_ms = to_epoch_ms(created_raw) if created_raw else int(
                 datetime.now().timestamp() * 1000,
             )

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@services/export_engine.py` around lines 386 - 392, The code retrieves `meta`
from the session dictionary but does not validate that it is actually a
dictionary before calling `.get()` on it. If the session contains a non-dict
value for the meta key (such as None or a string), calling
`meta.get("createdAt")` or `meta.get("name")` will raise an AttributeError. Add
a type guard to check that `meta` is a dictionary before using its `.get()`
methods, defaulting it to an empty dictionary if it is not the correct type, so
that subsequent `.get()` calls operate safely without raising AttributeError.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes